home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / gopher / Unix / gopher+1.2b4 / object / GDgopherdir.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-15  |  9.0 KB  |  472 lines
  1. /********************************************************************
  2.  * lindner
  3.  * 3.5
  4.  * 1993/04/15 21:35:12
  5.  * /home/mudhoney/GopherSrc/CVS/gopher+/object/GDgopherdir.c,v
  6.  * Exp
  7.  *
  8.  * Paul Lindner, University of Minnesota CIS.
  9.  *
  10.  * Copyright 1991, 1992 by the Regents of the University of Minnesota
  11.  * see the file "Copyright" in the distribution for conditions of use.
  12.  *********************************************************************
  13.  * MODULE: GDgopherdir.c
  14.  * Implement gopher directory routines
  15.  *********************************************************************
  16.  * Revision History:
  17.  * GDgopherdir.c,v
  18.  * Revision 3.5  1993/04/15  21:35:12  lindner
  19.  * Debug code, better .Link processing, better GDfromNet()
  20.  *
  21.  * Revision 3.4  1993/03/26  19:50:44  lindner
  22.  * Mitra fixes for better/clearer fromNet code
  23.  *
  24.  * Revision 3.3  1993/03/24  17:04:49  lindner
  25.  * bad strcmp() can check unmalloced() mem, fixed
  26.  *
  27.  * Revision 3.2  1993/03/18  22:13:29  lindner
  28.  * filtering, compression fixes
  29.  *
  30.  * Revision 3.1  1993/02/11  18:03:01  lindner
  31.  * Initial revision
  32.  *
  33.  * Revision 2.1  1993/02/09  22:46:50  lindner
  34.  * Many additions for gopher+
  35.  *
  36.  * Revision 1.4  1993/01/31  00:22:51  lindner
  37.  * Changed GDaddGS to merge entries with the same path.
  38.  * Added GDplusfromNet() to siphon data from network.
  39.  * GDfromLink now knows about ~/ inside of Path=
  40.  * Changed GDSearch to ignore leading character.
  41.  *
  42.  * Revision 1.3  1992/12/19  04:44:09  lindner
  43.  * Added GDplustoNet()
  44.  *
  45.  * Revision 1.2  1992/12/16  20:37:04  lindner
  46.  * Added function GDsearch(), does a linear search of a gopher directory
  47.  *
  48.  * Revision 1.1  1992/12/10  23:27:52  lindner
  49.  * gopher 1.1 release
  50.  *
  51.  *
  52.  *********************************************************************/
  53.  
  54.  
  55. #include "GDgopherdir.h"
  56. #include "Malloc.h"
  57.  
  58.  
  59. #include <string.h>
  60. #include <stdio.h>
  61. extern int DEBUG;
  62.  
  63.  
  64. /***********************************************************************
  65. ** Stuff for GopherDirObjs
  66. **
  67. ***********************************************************************/
  68.  
  69.  
  70. GopherDirObj*
  71. GDnew(size)
  72.   int size;
  73. {
  74.      int i;
  75.      GopherDirObj *temp;
  76.      
  77.      temp = (GopherDirObj*) malloc(sizeof(GopherDirObj));
  78.  
  79.      temp->Gophers = DAnew(size, GSnew, GSinit, GSdestroy, GScpy);
  80.  
  81.      temp->Title = STRnew();
  82.      temp->currentitem = 1;
  83.  
  84.      GDinit(temp);
  85.      return(temp);
  86. }
  87.  
  88.  
  89. void
  90. GDdestroy(gd)
  91.   GopherDirObj *gd;
  92. {
  93.      int i;
  94.  
  95.      DAdestroy(gd->Gophers);
  96.      
  97.      STRdestroy(gd->Title);
  98.      free(gd);
  99. }
  100.  
  101.  
  102. void
  103. GDinit(gd)
  104.   GopherDirObj *gd;
  105. {
  106.      int i;
  107.  
  108.      DAinit(gd->Gophers);
  109.      STRinit(gd->Title);
  110. }
  111.  
  112.  
  113. extern int DEBUG;
  114.  
  115. /** This proc adds a GopherObj to a gopherdir.
  116.     It will attempt to merge two items if need be..
  117.  **/
  118. void
  119. GDaddGSmerge(gd, gs)
  120.   GopherDirObj *gd;
  121.   GopherObj *gs;
  122. {
  123.     int num;
  124.  
  125.     num = GDSearch(gd, GSgetPath(gs));
  126.  
  127.     if (num == -1)
  128.          DApush(gd->Gophers, gs);
  129.      else {
  130.          GSmerge(GDgetEntry(gd, num),gs);
  131.     }
  132. }
  133.  
  134.  
  135. /*
  136.  * This one never tries to merge 
  137.  */
  138.  
  139. void
  140. GDaddGS(gd, gs)
  141.   GopherDirObj *gd;
  142.   GopherObj *gs;
  143. {
  144.     int num;
  145.  
  146.     if (GSgetType(gs) != 'X')
  147.          DApush(gd->Gophers, gs);
  148. }
  149.  
  150.  
  151. /*
  152.  * Really weird!!!  We need this for qsort,  don't know why we can't use
  153.  * GScmp...
  154.  */
  155.  
  156. int
  157. GSqsortcmp(gs1, gs2)
  158.   GopherObj **gs1, **gs2;
  159. {
  160.      if (GSgetTitle(*gs1) == NULL)
  161.       return(1);
  162.      if (GSgetTitle(*gs2) == NULL)
  163.       return(-1);
  164.      
  165.      /** No numbering set on either entry, or both numbered
  166.          entries have the same number   **/
  167.  
  168.      if (GSgetNum(*gs1) == GSgetNum(*gs2))
  169.       return(strcmp(GSgetTitle(*gs1), GSgetTitle(*gs2)));
  170.  
  171.      /** first one numbered, second not **/
  172.      if (GSgetNum(*gs1) != -1 && GSgetNum(*gs2) == -1)
  173.       return(-1);
  174.  
  175.      /** second one numbered, first not **/
  176.      if (GSgetNum(*gs1) == -1 && GSgetNum(*gs2) != -1)
  177.       return(1);
  178.  
  179.      /** Both numbered, integer compare them **/
  180.  
  181.      return(GSgetNum(*gs1) - GSgetNum(*gs2));
  182. }
  183.  
  184. /*
  185.  * Sorts a gopher directory
  186.  */
  187.  
  188. void
  189. GDsort(gd)
  190.   GopherDirObj *gd;
  191. {
  192.  
  193.      DAsort(gd->Gophers, GSqsortcmp);
  194. }
  195.  
  196.  
  197. void
  198. GDtoNet(gd, sockfd)
  199.   GopherDirObj *gd;
  200.   int sockfd;
  201. {
  202.      int i;
  203.      if (DEBUG) fprintf (stderr, "GDplustoNet\n");
  204.      for (i=0; i< GDgetNumitems(gd); i++) {
  205.       GStoNet(GDgetEntry(gd, i), sockfd);
  206.      }      
  207.  
  208. }
  209.  
  210.  
  211. void
  212. GDplustoNet(gd, sockfd, filter)
  213.   GopherDirObj *gd;
  214.   int          sockfd;
  215.   char         **filter;
  216. {
  217.      int i;
  218.  
  219.      for (i=0; i< GDgetNumitems(gd); i++) {
  220.       GSplustoNet(GDgetEntry(gd, i), sockfd,filter);
  221.      }      
  222. }
  223.  
  224. void
  225. GDtoNetHTML(gd, sockfd)
  226.   GopherDirObj *gd;
  227.   int sockfd;
  228. {
  229.      int i;
  230.      
  231.      writestring(sockfd, "<MENU>\r\n");
  232.      
  233.      for (i=0; i< GDgetNumitems(gd); i++) {
  234.       writestring(sockfd, "<LI>");
  235.       GStoNetHTML(GDgetEntry(gd, i), sockfd);
  236.      }      
  237.      writestring(sockfd, "</MENU>");
  238. }
  239.  
  240. /*
  241.  * Gopher+ counterpart to GDfromNet()
  242.  */
  243.  
  244.  
  245. #define DODEBUG(loc) if (DEBUG) { fprintf(stderr,"GDplusfromNet:%s;\n",loc);}
  246.  
  247. int
  248. GDplusfromNet(gd, fd, eachitem)
  249.   GopherDirObj *gd;
  250.   int fd;
  251.   int (*eachitem)();
  252. {
  253.      static GopherObj *TempGopher;
  254.      static char ZesTmp[1024];
  255.      int j, result;
  256.      char inputline[256];
  257.  
  258.      DODEBUG("start")
  259.      if (TempGopher == NULL)
  260.       TempGopher = GSnew();
  261.  
  262.      /** State: _begin_ **/
  263.  
  264.      result = readrecvbuf(fd, inputline, 1);
  265.      if (result <=0 || *inputline != '+') 
  266.       return(0);
  267.  
  268.      DODEBUG("after readrecvbuf")
  269.      /** State _FirstPlus_ **/
  270.  
  271.      result = readtotoken(fd, inputline, sizeof(inputline), ':');
  272.      if (result <=0)
  273.       return(result);
  274.  
  275.      DODEBUG("after readtotoken")
  276.      if (strcmp(inputline, "INFO")!=0) {
  277.       return(0);
  278.      }
  279.      DODEBUG("after INFO")
  280.      /** Read the space **/
  281.      readrecvbuf(fd, inputline, 1);
  282.  
  283.  
  284.      /*** State _FirstINFO_ ***/
  285.  
  286.      for (j=0; ; j++) {
  287.  
  288.            DODEBUG("for start")
  289.       ZesTmp[0] = '\0';
  290.       
  291.       GSinit(TempGopher);
  292.       result = GSplusfromNet(TempGopher, fd);
  293.       
  294.       switch (result) {
  295.       case MORECOMING:
  296.            GDaddGS(gd, TempGopher);
  297.            if (eachitem != NULL) 
  298.             eachitem();
  299.            break;
  300.  
  301.       case FOUNDEOF:
  302.            GDaddGS(gd, TempGopher);
  303.            return(j+1);
  304.  
  305.       case HARDERROR:  /** Give up reading - bad read or protocol error **/
  306.            return(j);
  307.  
  308.       case SOFTERROR:  /** This one was bad, but we can try for next **/
  309.            j= j-1;
  310.            if (j<0) j=0;
  311.            break;
  312.       }
  313.            
  314.      } /* for */
  315.  
  316.      /** Never get here **/
  317. } 
  318.  
  319. /*
  320.  * Fill up a GopherDirObj with GopherObjs, given a gopher directory coming
  321.  * from sockfd.
  322.  *
  323.  * For each GopherObj retrieved, eachitem() is executed.
  324.  *
  325.  */
  326.  
  327. void
  328. GDfromNet(gd, sockfd, eachitem)
  329.   GopherDirObj *gd;
  330.   int sockfd;
  331.   int (*eachitem)();
  332. {
  333.      static GopherObj *TempGopher;
  334.      static char ZesTmp[1024];
  335.      int i;
  336.  
  337.      if (DEBUG) fprintf(stderr, "GDfromNet...");
  338.      if (TempGopher == NULL)
  339.       TempGopher = GSnew();
  340.  
  341.      for (; ;) {
  342.  
  343.       ZesTmp[0] = '\0';
  344.       
  345.       GSinit(TempGopher);
  346.       i = GSfromNet(TempGopher, sockfd);
  347.       
  348.          /* In gopher+1.2b2 this routine clears up if GSfromNet returns 
  349.             a failure, better to clear up in GSfromNet so that the 
  350.             system returns in a known state - note that other callers of 
  351.             GSfromNet didn't clean up and crashed! */
  352.       
  353.       switch (i) {
  354.  
  355.       case 0:
  356.            GDaddGS(gd, TempGopher);
  357.            if (eachitem != NULL) eachitem();
  358.            break;
  359.  
  360.       case 1:  /* . on a line by itself, nothing more */
  361.            return;
  362.  
  363.       case SOFTERROR:  /** Unknown object type **/
  364.            break;
  365.  
  366.       case HARDERROR:
  367.            return;
  368.       }
  369.      }
  370. } 
  371.  
  372.  
  373. /*
  374.  * Given an open file descriptor and an inited GopherDirobj,
  375.  *   read in gopher links, and add them to a gopherdir
  376.  */
  377.  
  378. void
  379. GDfromLink(gd, fd, host, port, directory)
  380.   GopherDirObj *gd;
  381.   int          fd;
  382.   char         *host;
  383.   int          port;
  384.   char         *directory;
  385. {
  386.      GopherObj *gs;
  387.      char      testline[512];
  388.      int       num;
  389.      int result;
  390.  
  391.      gs = GSnew();
  392.  
  393.  
  394.      while (1) {
  395.       result = GSfromLink(gs, fd, host, port,directory);
  396.  
  397.       if (result == HARDERROR)
  398.            break;
  399.       if (result == SOFTERROR)
  400.            continue;
  401.  
  402.       if (*GSgetPath(gs) == '.')
  403.            GDaddGSmerge(gd, gs);
  404.       else
  405.            GDaddGS(gd, gs);
  406.  
  407.       if (result == FOUNDEOF)
  408.            break;
  409.  
  410.       GSinit(gs);
  411.      }
  412.       
  413.      GSdestroy(gs);
  414. }
  415.  
  416.  
  417. void
  418. GDtoLink(gd, fd)
  419.   GopherDirObj *gd;
  420.   int fd;
  421. {
  422.      int i;
  423.  
  424.      for (i=0; i< GDgetNumitems(gd); i++) {
  425.       GStoLink(GDgetEntry(gd, i), fd);
  426.      }      
  427.  
  428. }
  429.  
  430. /***  Search for a specific gopher item ***/
  431. /* Allow text to end in .Z - gd will never have a .Z item in it due to fix 
  432.    in gopherd/gopherd */
  433. int
  434. GDSearch(gd, text)
  435.   GopherDirObj *gd;
  436.   char         *text;
  437. {
  438.      int i;
  439.      int WasCtrlZ = 0;
  440.      GopherObj *gs;
  441.      int len;
  442.  
  443.      if (gd == NULL)
  444.       return(-1);
  445.  
  446.      if (text == NULL)
  447.       return(-1);
  448.  
  449.      len = strlen(text);
  450.      if (len >2) {
  451.       WasCtrlZ = (strcmp(text+strlen(text)-2,".Z")  == 0);
  452.       if (WasCtrlZ) 
  453.            text[strlen(text)-2] = '\0';
  454.      }
  455.     
  456.      for (i=0; i< GDgetNumitems(gd); i++) {
  457.       gs = GDgetEntry(gd, i);
  458.  
  459.       if (len >1 && strcmp(text+1, GSgetPath(gs)+1) == 0) {
  460.            if (WasCtrlZ) 
  461.             text[strlen(text)-2] = '.';
  462.         if (DEBUG) fprintf (stderr, "Matched\n");
  463.            return(i);
  464.       }
  465.      }
  466.      if (WasCtrlZ) 
  467.     text[strlen(text)-2] = '.';
  468.      if (DEBUG) fprintf (stderr, "No Match\n");
  469.      return(-1);
  470. }
  471.  
  472.